// a voir
//  pose du comportement sur obj js diff du Html pb?
// concurrence RS et DD affect? ? mm div
// limite top par d?faut outrpass?e lorsque rs nordth
//   partage du cadre fantome entre DD et RS
//   grille magnetique  + deformation symetrique  ? implementer
// verifier les valeurs de retour mod.left, mod.top
// revoir avec Mozilla si bordure large pb direction passe en mode diagonal avant coin bas

var ENREG_RS = 99;           // niveau de trace du DD = 99
var oReSize= null;
var defMargeSensibleDD = 3;
var SENSITIVEEDGEWIDTH_DEFAULT = 3

rialto.widgetBehavior.RSLoadLimitsDyn
= function(oBase) {
//===============================
// limites right-bottom du deplact fct? des dim d'un elt Html (en g?n?ral du parent) au moment du MouseDown
  // calcul / pere
//traceExec('RSLoadLimitsDyn entree');
  // les limites font parties des specs de cr?ation de l'objet ayant le comportement RS
  // il faut juste r??valuer leurs valeurs
  if (this.limitReDim.bRectLim) {
    this.limitReDim.rectLim.bottom      =  eval(this.limitReDim.rectLim.bottomSpecs);
    this.limitReDim.rectLim.right       =  eval(this.limitReDim.rectLim.rightSpecs);
  }
  // pas de directives sp?ciales dans les specs de cr?ation : on utilise les dimensions du parent
  else {
    this.limitReDim.rectLim.bottom      =  pixHeight(oBase);
    this.limitReDim.rectLim.right       =  pixWidth(oBase);
  }
  
  // si max fix?s ? la cr?ation on conserve ces valeurs sinon calcul 
  // corrig? (manquait .retLim.) le 6/04/2004 pour curs a verifier ds d autres ctxte
/*modif du 28/04/2003
  this.limitReDim.widthMax    =   this.limitReDim.widthMax 
                               || (this.limitReDim.rectLim.right - this.limitReDim.rectLim.left + 1);
  this.limitReDim.heightMax   =   this.limitReDim.heightMax 
                               || (this.limitReDim.rectLim.bottom - this.limitReDim.rectLim.top + 1);
*/
  if (this.limitReDim.bLimMax) {
    this.limitReDim.widthMax    =   eval(this.limitReDim.widthMaxSpecs); 
    this.limitReDim.heightMax   =   eval(this.limitReDim.heightMaxSpecs);
  }
  else {
    this.limitReDim.widthMax    =  (this.limitReDim.rectLim.right - this.limitReDim.rectLim.left + 1);
    this.limitReDim.heightMax   =  (this.limitReDim.rectLim.bottom - this.limitReDim.rectLim.top + 1);
  }

traceExec('RSLoadLimitsDyn id= '+this.id+' this.limitReDim.rectLim.top = '+ this.limitReDim.rectLim.top,60);
traceExec('RSLoadLimitsDyn this.limitReDim.rectLim.left = '+ this.limitReDim.rectLim.left,58);

traceExec('RSLoadLimitsDyn this.limitReDim.rectLim.bottom = '+ this.limitReDim.rectLim.bottom,60);
traceExec('RSLoadLimitsDyn this.limitReDim.rectLim.right = '+ this.limitReDim.rectLim.right,58);

traceExec('RSLoadLimitsDyn this.limitReDim.rectLim.widthMax = '+ this.limitReDim.widthMax,58);
traceExec('RSLoadLimitsDyn this.limitReDim.rectLim.heightMax = '+ this.limitReDim.heightMax,60);

}

rialto.widgetBehavior.RSLoadSpecs
= function (specs) {
//===========================
// limitDeplact =
//    {  mobilite    : DragAndDrop / ReSize,      type de mobilite
//       majDyn      : true / false               dim bottom-right des limites / parent calcul?es dyn lors du MouseDown
//       orientation : h,v,2D,                    orientation autoris?e du mouvement
//       posRelI     : { top: , left}             position initiale / parent
//       rectLimit   : {                          coordonn?es / parent du cadre limitant le mouvement (deplacement ou redimensionnenement)
//                       top:
//                       left:
//                       bottom:
//                       right:}
//       cibleEvt    :  target / targetAndCo      cible autoris?e pour d?clencher le mvt : ?tendue ou non ? la descendance de l'oHtml
//                                                ayant le comportement DD
//       circulaire  : true /false                le d?placement est circulaire / cadre limite --> arriver en bas le d?plact se poursuit en haut
//		 sensitiveEdgeWidth : <nb pixel>		  width of sensitive margin for Resize 
//     }

traceExec('RSLoadSpecs entree',76);
this.specsRS = new Object;

if (! specs)
  specs = new Object;

//--- cibles potentielles
//alert('RSLoadSpecs specs.cibleEvt= '+specs.cibleEvt) ;
 if (!specs.cibleEvt){
   this.specsRS.cibleEvt = new Array;
   this.specsRS.cibleEvt[0] = {oHtml: this, mode:'mono', dir:'2D'};
   this.specsRS.orientation = '2D';
 }
 else
 if (! (specs.cibleEvt instanceof Array)){
   var wCibleEvt = specs.cibleEvt;
   this.specsRS.cibleEvt = new Array;
   this.specsRS.cibleEvt[0] = new Object;
   this.specsRS.cibleEvt[0].oHtml = wCibleEvt.oHtml;
   this.specsRS.cibleEvt[0].mode  = wCibleEvt.mode || 'mono';
   var orientation = specs.orientation || '2D';
   this.specsRS.cibleEvt[0].dir   = (this.specsRS.cibleEvt[0].mode == 'mono') ? orientation : wCibleEvt.dir;
   this.specsRS.orientation = this.specsRS.cibleEvt[0].dir;
 }
 else
 if (specs.cibleEvt instanceof Array){
   this.specsRS.cibleEvt = specs.cibleEvt;
 }
 else{
   traceExec('pb def cible DD',30);
 }
// a voir eventuellement --- limitations internes aux cibles potentielles (notion de marge)
// for (var i=0; i <this.specsRS.objetCibleEvt; i++){
//  if (this.specsRS.objetCibleEvt[i].exclusionMarge)
//  ...
//}

//define sensitive margin to mouse move for resize
this.specsRS.sensitiveEdgeWidth = specs.sensitiveEdgeWidth || SENSITIVEEDGEWIDTH_DEFAULT;

//--- objet Html ? deformer in fine
 this.specsRS.objetADeformer = specs.objetADeformer ?  specs.objetADeformer : this;

//--- apparence du d?placement
this.specsRS.fantome = new Object;
if (specs.fantome)
   this.specsRS.fantome.aspect = specs.fantome.aspect || 'cadre';
else
   this.specsRS.fantome = null;

// this.specsRS.fantome        = specs.fantome        ?  specs.fantome        : false;

//--- modif apparence du curseur
  this.specsRS.modCurs = new Object;
  if (specs.modCursor){
    this.specsRS.modCurs.avantDD   = (specs.modCursor.avantDD != 'undefined') ? specs.modCursor.avantDD : true;
    this.specsRS.modCurs.auClic    = (specs.modCursor.auClic  != 'undefined') ? specs.modCursor.auClic  : true;
  }
  else {
    this.specsRS.modCurs.avantDD = true;
    this.specsRS.modCurs.auClic  = true;
  }

//--- grille magnetique
   if (specs.grilleMagnetic){
      this.specsRS.magnet = new Object;
      this.specsRS.magnet.widthCol  = specs.grilleMagnetic.widthCol  || 10;
      this.specsRS.magnet.heightRow = specs.grilleMagnetic.heightRow || 10;
   }


this.limitReDim = new Object;
//--- symetrie de la deformation
 this.limitReDim.symetrie  = specs.symetrie || false;

  // symetrie --> centrage
  if (this.limitReDim.symetrie)
      this.limitReDim.centrage = true;

// deplacement circonscrit ? un rectangle 
// dont les coordonn?es sont relatives au parent de l'objet ? deplacer in fine
// --> n?cessite le chargement pr?alable ds la page de ces objets (sinon param?trer le DD avec majDyn = true)

 // r?gles appliqu?es :
 //  - par d?faut bRectLim = true
 //  - specs.bRectLim = false et specs.rectLim d?fini incompatibles --> bRectLim forc? ? true
 //  - si bRectLim et pas de .rectLim d?fini dimension de rectLim par d?faut : 0,0,f(parent),f(parent) utilis?s
 this.limitReDim.bRectLim = (specs.bRectLim != null) ? specs.bRectLim :  true;
 this.limitReDim.bLimMax = (specs.bRectLim != null) ? specs.bLimMax :  false;

this.limitReDim.rectLim = new Object;
var flagModSpecsRectLim = false;
 if (!specs.rectLim) {
   specs.rectLim = new Object;  // simplement pour ?viter les cas particuliers ds le code ci-dessous
   flagModSpecsRectLim = true; 
 }
 else {
   this.limitReDim.bRectLim = true;
 }
 
 // on prend les limites definies , pour les autres top=left=0 bottom et right f(parent)
 // top - left
 this.limitReDim.rectLim.left        =  specs.rectLim.left       || 0;  // ajouter eval(...
 this.limitReDim.rectLim.top         =  specs.rectLim.top ;//       || 0;

//--- calcul dynamique (au Md) des limites du d?placement
 this.specsRS.majDyn         = (specs.majDyn != null)    ?  specs.majDyn         : true;


// bottom - right  
 // (ne sont pas calcul?es ds LoadLimit si le chargt dynamique est demand?, afin d'attendre ?ventuellt le chargt des elts ds la page)
 if (!this.specsRS.majDyn){  
 // ajouter eval(...
     this.limitReDim.rectLim.right       =  specs.rectLim.right      || pixWidth(this.specsRS.objetADeformer.parentNode);
     this.limitReDim.rectLim.bottom      =  specs.rectLim.bottom     || pixHeight(this.specsRS.objetADeformer.parentNode);
}
 else {
   this.limitReDim.rectLim.rightSpecs  =  specs.rectLim.right      || pixWidth(this.specsRS.objetADeformer.parentNode);
   this.limitReDim.rectLim.bottomSpecs =  specs.rectLim.bottom     || pixHeight(this.specsRS.objetADeformer.parentNode);

   this.limitReDim.widthMaxSpecs =  specs.rectLim.widthMax;  
   this.limitReDim.heightMaxSpecs =  specs.rectLim.heightMax;

}
// else chargt dynamique pdt Md

  if (!specs.limitReDim) specs.limitReDim = new Object;
  // tailles max et min de l'objet Html apres deformation
  this.limitReDim.heightMin   =  specs.limitReDim.heightMin  || 10;
  this.limitReDim.heightMax   =  specs.limitReDim.heightMax  || (this.limitReDim.bottom - this.limitReDim.top + 1);
traceExec('** RSLoadSpecs specs.limitReDim.widthMin    = ' + specs.limitReDim.widthMin,76);
  this.limitReDim.widthMin    =  specs.limitReDim.widthMin   || 10;
traceExec('** RSLoadSpecs this.limitReDim.rectLim.widthMin    = ' + this.limitReDim.widthMin,76);
  this.limitReDim.widthMax    =  specs.limitReDim.widthMax   || (this.limitReDim.right - this.limitReDim.left + 1);

traceExec('RSLoadSpecs this.limitReDim.rectLim.top    = ' + this.limitReDim.rectLim.top,76);
traceExec('RSLoadSpecs this.limitReDim.rectLim.left   = ' + this.limitReDim.rectLim.left,76);
traceExec('RSLoadSpecs this.limitReDim.rectLim.bottom = ' + this.limitReDim.rectLim.bottom,76);
traceExec('RSLoadSpecs this.limitReDim.rectLim.right  = ' + this.limitReDim.rectLim.right,76);
traceExec('RSLoadSpecs this.limitReDim.rectLim.bottomSpecs = ' + this.limitReDim.rectLim.bottomSpecs,76);
traceExec('RSLoadSpecs this.limitReDim.rectLim.rightSpecs  = ' + this.limitReDim.rectLim.rightSpecs,76);

traceExec('RSLoadSpecs this.limitReDim.rectLim.heightMin   = ' + this.limitReDim.heightMin,76);
traceExec('RSLoadSpecs this.limitReDim.rectLim.heightMax   = ' + this.limitReDim.heightMax,76);
traceExec('RSLoadSpecs this.limitReDim.rectLim.widthMin    = ' + this.limitReDim.widthMin,76);
traceExec('RSLoadSpecs this.limitReDim.rectLim.widthMax    = ' + this.limitReDim.widthMax,76);

//traceExec('RSLoadSpecs this.limitReDim.symetrie = ' + this.limitReDim.symetrie);

//traceExec('RSLoadSpecs this.specsRS.majDyn = '+ this.specsRS.majDyn);

//traceExec('RSLoadSpecs this.limitReDim.bRectLim = '+ this.limitReDim.bRectLim);
/*
if (specs.fantome)
   traceExec('RSLoadSpecs this.specsRS.fantome.aspect = '+this.specsRS.fantome.aspect);
else
   traceExec('RSLoadSpecs this.specsRS.fantome = null');

if (specs.grilleMagnetic){
   traceExec('RSLoadSpecs this.specsRS.magnet.widthCol = ' + this.specsRS.magnet.widthCol);
   traceExec('RSLoadSpecs this.specsRS.magnet.heightRow = ' + this.specsRS.magnet.heightRow);
}
if (specs.modCursor){
   traceExec('RSLoadSpecs this.specsRS.modCurs.avantDD = '+this.specsRS.modCurs.avantDD);
   traceExec('RSLoadSpecs this.specsRS.modCurs.auClic = '+this.specsRS.modCurs.auClic);
}
*/
traceExec('RSLoadSpecs fin',58);

if (   flagModSpecsRectLim)
	specs.rectLim = null;
}




//_________________________________________________________________________________________________________________________________
rialto.widgetBehavior.constructorReSize
= function (specs) 
//=========================
// restriction : par defaut calcul dynamique des limites deplact --> si pas de d?finition du rect lim
//   une r?f?rence au parent est r?alis?e --> son existence doit ?tre assurer avant l'appel de ReSize sans specs
//        specs = {
//                }
{
          // cr?ation de l'attribut de l'oCiu stockant les infos relatives au DD
          if (!this.oCiu) this.oCiu = new Array();
          this.oCiu['ReSize'] = this;
          this.oCiu['ReSize'].lockReSize = false;

          // chargement des sp?cifications du d?placement
          // r?f?rence aux m?thodes de chargt par d?faut en absence de m?thodes sp?cifiques ? l'oCiu
          if (!this.oCiu['ReSize'].loadSpecsRS){
             this.oCiu['ReSize'].loadSpecsRS = rialto.widgetBehavior.RSLoadSpecs; // modif du 23/12/2003
//             alert('pas de loadSpecs');
          }
//alert(this.oCiu['ReSize'].loadSpecs);
          // chargement des limites non dynamiques   (dynamiques cf. mouseDown)
          this.oCiu['ReSize'].loadSpecsRS(specs);
//alert('specs.cibleEvt= ' + this.oCiu['ReSize'].cibleEvt) ;


             // pour le chargt dynamique, r?f?rence ? la m?thode dynamique standart
             if (this.oCiu['ReSize'].specsRS.majDyn) {
                if (!this.oCiu['ReSize'].loadLimitsDynRS)   // modif du 23/12/2003
                   this.oCiu['ReSize'].loadLimitsDynRS = rialto.widgetBehavior.RSLoadLimitsDyn;
                //alert("this.oCiu['ReSize'].specsRS.objetADeformer.id = "+this.oCiu['ReSize'].specsRS.objetADeformer.id);
                this.oCiu['ReSize'].loadLimitsDynRS(this.oCiu['ReSize'].specsRS.objetADeformer.parentNode);   
            }

             // inscrit dans l'objet Html directement (ou via des pointeurs vers) les infos relatives au ReSize
             var oCiu = this.oCiu['ReSize'];
             var oHtmlCible;
             for (var i=0; i < oCiu.specsRS.cibleEvt.length; i++) {
                 oHtmlCible = oCiu.specsRS.cibleEvt[i].oHtml;

                 oHtmlCible.reSize   = true;                         // marque l oHtml comme deformable
                 oHtmlCible.refObjSpecsRS = this;                    // pointeur vers les specifs g?n?rales
                 oHtmlCible.modeRS = oCiu.specsRS.cibleEvt[i].mode;    // reaction uniforme ou non / pos clic sur oHtml
                 oHtmlCible.dirRS  = oCiu.specsRS.cibleEvt[i].dir;     // direction (si comportement = mono)

				 if (!oHtmlCible.behavior) 
				 	oHtmlCible.behavior = {};
				 if (!oHtmlCible.behavior['RS'])
				 	oHtmlCible.behavior['RS'] = {};
				 oHtmlCible.behavior['RS'].running  = false;
	       }

          // enregistrement comportement DD pour navigateur IE
          //(pas d'utilisation de attachEvent qui rend this indisponible -> utilisation d'1 m?thode maison addHandler)
          if ( typeof document.addEventListener == "undefined"){

                 // enregistrement du MDown
                 //var tOCible =  oCiu.specsRS.cibleEvt;

                 for (var i=0; i < oCiu.specsRS.cibleEvt.length; i++) {
                   oHtmlCible = oCiu.specsRS.cibleEvt[i].oHtml;

                   oHtmlCible.addHandler = addHandler;

                   oHtmlCible.methodRSMouseDown = rialto.widgetBehavior.ReSizeMouseDownHandler;
                   oHtmlCible.methodRSMouseMove = rialto.widgetBehavior.ReSizeMouseMoveHandler;
                   oHtmlCible.methodRSMouseUp   = rialto.widgetBehavior.ReSizeMouseUpHandler;

                   oHtmlCible.addHandler(oHtmlCible,'onmousedown','methodRSMouseDown');
                   oHtmlCible.addHandler(oHtmlCible,'onmousemove','methodRSMouseMove');
                   oHtmlCible.addHandler(oHtmlCible,'onmouseup','methodRSMouseUp');

                   // pour test
                   oHtmlCible.methodDebRS   = function (){window.status ='debut de la deformation this.id='+this.id;};
                   oHtmlCible.addHandler(oHtmlCible,'onmousedown','methodDebRS');
                   oHtmlCible.methodFinRS   = function (){window.status ='fin de la deformation';};
                   oHtmlCible.addHandler(oHtmlCible,'onmouseup','methodFinRS');
                 }

//  = extension de :              this.onmousedown = rialto.widgetBehavior.ReSizeMouseDownHandler;
//                                this.onmousemove = rialto.widgetBehavior.ReSizeMouseMoveHandler;
//                                this.onmouseup   = rialto.widgetBehavior.ReSizeMouseUpHandler;
          }

          // enregistrement W3C
          else{
              if (!document.enregtReSize){
                 document.enregtReSize = true;
                 document.addEventListener("mousemove",rialto.widgetBehavior.ReSizeMouseMoveHandler, false);
                 document.addEventListener("mouseup",  rialto.widgetBehavior.ReSizeMouseUpHandler, false);
                 document.addEventListener("mousedown",rialto.widgetBehavior.ReSizeMouseDownHandler, false);
                 // pour supprimer le comportement par defaut de selection d'image propre ? Mozilla lors du MouseDown
                 document.addEventListener("mousedown",StopSelectDef,false);
//                 oHtmlCible.addEventListener("mousedown",StopSelectDef,false);
// ne marche pas pourquoi ?                 document.addEventListener("mousedown",stopDefault,false);
              }
          }


}  // end constructor



//====  create re-size behavior  ======
rialto.widgetBehavior.createBehavior(
	'ReSize',
	rialto.widgetBehavior.constructorReSize
);


StopSelectDef = function(e){
//======================
   stopDefault(e);
}



 